package qc.module.platform.api.controller;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import qc.common.core.exception.QCPromptException;
import qc.common.core.json.JsonParserUtil;
import qc.module.platform.dto.db.DBConnectionDto;
import qc.module.platform.dto.db.DBDto;
import qc.module.platform.entity.QcDb;
import qc.module.platform.entity.QcDbTable;
import qc.module.platform.service.DbService;
import qc.module.platform.service.DbTableService;

import java.util.List;

/**
 * DbController
 *
 * @author QuCheng Tech
 * @since 2024/2/1
 */
@RestController
@RequestMapping("/db")
public class DbController {
    @Autowired
    private DbService service;

    @Autowired
    private DbTableService dbTableService;

    /**
     * 获取所有
     *
     * @return 返回数据库信息集合
     * @author QuCheng
     * @since 2024/3/12
     */
    @GetMapping("/all")
    public List<DBDto> getAll() {
        return service.getAll();
    }

    /**
     * 获取指定——支持RequestParam
     * @param id 数据库代码
     * @return 返回指定数据库信息
     * @author QuCheng
     * @since 2024/3/12
     */
    @GetMapping("get")
    public DBDto getByParam(@RequestParam String id) throws QCPromptException {
        return service.get(id);
    }

    /**
     * 获取指定——支持PathVariable
     * @param id 数据库代码
     * @return 返回指定数据库信息
     * @author QuCheng
     * @since 2024/3/12
     */
    @GetMapping("get/{id}")
    public DBDto getByPath(@PathVariable String id) throws QCPromptException {
        return service.get(id);
    }

    /**
     * 新增
     * @param dbDto
     * @return 成功返回null，失败返回错误信息
     * @author QuCheng
     * @since 2024/3/12
     */
    @RequestMapping(value = "/add", method = {RequestMethod.GET, RequestMethod.POST})
    public String add(@RequestBody DBDto dbDto){
        return service.add(dbDto);
    }

    /**
     * 修改
     * @param dbDto
     * @return 成功返回null，失败返回错误信息
     * @author QuCheng
     * @since 2024/3/12
     */
    @RequestMapping(value = "/update", method = {RequestMethod.POST, RequestMethod.PUT})
    public String update(@RequestBody DBDto dbDto){
        return service.update(dbDto);
    }

    /**
     * 删除——支持RequestParam，同时删除数据库表、数据库表sql和数据库表列中的信息。
     * @param id 数据库代码
     * @return 成功返回null，失败返回错误信息
     * @author QuCheng
     * @since 2024/3/12
     */
    @DeleteMapping("/delete")
    public String deleteByParam(@RequestParam String id) throws QCPromptException {
        return service.delete(id);
    }

    /**
     * 删除——支持PathVariable，同时删除数据库表、数据库表sql和数据库表列中的信息。
     *
     * @param id 数据库代码
     * @return 成功返回null，失败返回错误信息
     * @author QuCheng
     * @since 2024/3/12
     */
    @DeleteMapping("/delete/{id}")
    public String deleteByPath(@PathVariable String id) throws QCPromptException {
        return service.delete(id);
    }

    /**
     * 获取指定数据库表的连接信息
     *
     * @param id 数据库表编码
     * @return qc.module.platform.dto.db.DBConnectionDto
     * @author QuCheng Tech
     * @since 2025/10/31
     */
    @GetMapping("tablecon")
    public DBConnectionDto getTableConnectionByParam(@RequestParam String id) throws QCPromptException {
        return getTableConnection(id);
    }

    /**
     * 获取指定数据库表的连接信息
     *
     * @param id 数据库表编码
     * @return qc.module.platform.dto.db.DBConnectionDto
     * @author QuCheng Tech
     * @since 2025/10/31
     */
    @GetMapping("tablecon/{id}")
    public DBConnectionDto getTableConnectionByPath(@PathVariable String id) throws QCPromptException {
        return getTableConnection(id);
    }

    /**
     * 获取指定数据库表的连接信息
     *
     * @param tableCode 数据库表编码
     * @return qc.module.platform.dto.db.DBConnectionDto
     * @author QuCheng Tech
     * @since 2025/10/31
     */
    DBConnectionDto getTableConnection(String tableCode) throws QCPromptException {
        //先根据数据库表编码获取数据库编码，在根据数据库编码获取数据库信息，再解析出数据库连接字符串中的连接信息
        if (StringUtils.isBlank(tableCode))
            throw new QCPromptException("查询数据库连接信息时指定的数据库表编码不能为空");
        QcDbTable table = dbTableService.getEntity(tableCode);
        if (table == null)
            throw new QCPromptException("查询数据库连接信息时指定的数据库表编码获取到的数据库表信息为空");
        if (StringUtils.isBlank(table.getDb()))
            throw new QCPromptException("查询数据库连接信息时指定的数据库表编码获取到的数据库表信息中的所属数据库为空");
        String dbcode = table.getDb();
        QcDb db = service.getEntity(dbcode);
        if (db == null)
            throw new QCPromptException("查询数据库连接信息时指定的数据库信息为空");

        //如果数据库中的连接信息为空，不抛出异常
        DBConnectionDto result = new DBConnectionDto();
        result.setCode(db.getCode());
        result.setName(db.getName());
        result.setCon(db.getCon());
        if (StringUtils.isNotBlank(db.getCode())) {
            //解析数据库连接信息
            String dbConJsonString = db.getCon();
            if (StringUtils.isNotBlank(dbConJsonString)) {
                //Json对象进行获取
                String dbUrl = JsonParserUtil.getString(dbConJsonString, "url");
                String dbUser = JsonParserUtil.getString(dbConJsonString, "user");
                String dbPassword = JsonParserUtil.getString(dbConJsonString, "password");

                result.setUrl(dbUrl);
                result.setUser(dbUser);
                result.setPassword(dbPassword);
            }
        }

        return result;
    }
}
